Watch: Async Fundamentals

Right now, when you generate prompts for 3 platforms, your code does this:

1. Call Claude for Kling → wait 2 seconds → get result
2. Call Claude for Runway → wait 2 seconds → get result
3. Call Claude for Veo → wait 2 seconds → get result
4. Total: ~6 seconds

With async, it does this:

1. Start all 3 calls simultaneously
2. Wait for all 3 to finish
3. Total: ~2 seconds

Same work, 3x faster. For batch generation (20 shots × 3 platforms = 60 API calls), the difference is minutes vs. seconds.

Synchronous waiter: Takes table 1's order → walks to kitchen → waits for food → brings it back → walks to table 2. Takes table 2's order → walks to kitchen → waits for food → brings it back. Customers at table 2 wait for the whole cycle.

Async waiter: Takes table 1's order → sends it to kitchen → takes table 2's order → sends it → takes table 3's order → sends it → brings food to tables as it comes out. Kitchen is doing the slow work. The waiter (your Python code) never just stands around waiting.

One waiter. Same kitchens. But the waiter never blocks — it moves to the next task whenever it's waiting on something else. That's async.

async def defines a coroutine — a function that can pause and resume. await is the pause point. When Python hits await, it pauses that coroutine and runs other ready coroutines until the awaited thing completes.

# Regular function — can't pause, blocks everything
def regular():
    result = slow_operation()  # blocks for 2 seconds
    return result

# Async function — can pause at 'await', lets other things run
async def async_version():
    result = await slow_operation()  # pauses here, but doesn't block other tasks
    return result

import asyncio

async def main():
    # Run three things in parallel. gather() starts them all,
    # then waits for all to finish and returns all results.
    results = await asyncio.gather(
        task_one(),
        task_two(),
        task_three(),
    )
    # results is a list: [result_of_one, result_of_two, result_of_three]
    # They're in the same order as you passed them in.
    return results

asyncio.run(main())  # starts the async event loop

The Anthropic SDK has an async version of the client. Same API, but every method call needs await:

# Sync (one at a time):
client = anthropic.Anthropic()
message = client.messages.create(...)  # blocks

# Async (can run in parallel):
client = anthropic.AsyncAnthropic()
message = await client.messages.create(...)  # pauses without blocking